Implement some more vfuncs in GdkOffscreenWindow

More include shuffling; keep X extension headers to ourselves

Check the right library for symbols

Fix another typo

Fix a silly typo

Disable the GtkPlug xi2 hack more thoroughly

Detangle includes for GdkDeviceManager subclasses

Detangle includes for device subclasses

Forgotten file

Rename GdkAppLaunchContextX11 to GdkX11AppLaunchContext

Rename GdkDragContextX11 to GdkX11DragContext

Don't export gdk_x11_cursor_finalize

Get abicheck to almost pass again

Rename x11-specific GdkDevice[Manager] implementations

Make them all fit in the gdk_x11_ prefix, and make the
get_type functions and standard macros available in headers.

Rename GdkDevice[Manager]Core to GdkX11Device[Manager]Core

This is mainly to avoid clash with the classes of the same
name in the quartz backend.

Rename GdkKeymapX11 to GdkX11Keymap

And add a gdkx11keys.h header file.

Rename GdkDisplayManagerX11 to GdkX11DisplayManager

And add a gdkx11displaymanager.h header file.

gdk: Make GdkWindow abstract

This way backend implementors get an error if they don't set
display_class->window_type to their subclass. And that's exactly what we
want.

gdk: Use G_DEFINE_TYPE for GdkWindow

x11: Add a GdkX11Window class for X11 windows

gdk: Allow display subclasses to override the type used for windows

We want to have different window types for different displays, so we can
write code like this:

  #if GDK_WINDOWING_X11
    if (GDK_IS_X11_WINDOW (window))
      {
        /* do x11 stuff */
      }
    else
  #endif
  #if GDK_WINDOWING_WAYLAND
    if (GDK_IS_WAYLAND_WINDOW (window))
      {
        /* do wayland stuff */
      }
    else
  #endif
      {
        /* do stuff for unsupported system */
    }

This requires different GdkWindow types and we currently don't have
that, as only the GdkWindowImpl differs. With this method, every backend
defines a custom type that's just a simple subclass of GdkWindow. This
way GdkWindow behaves like all the other types (visuals, screens,
displays) and we can write code like the above.

gdk: Create windows via _gdk_display_create_window()

THe use of this function will become visible in the next commits. But
wrapping g_object_new() is a generally a good idea anyway.

x11: Export GdkX11Screen

x11: Rename GdkScreenX11 to GdkX11Screen

x11: Export GdkX11Visual

x11: Rename GdkVisualX11 to GdkX11Visual

x11: Have a proper GdkVisualX11Class struct

x11: Export GdkX11Cursor

x11: typedef GdkX11Display to GdkDisplay

This is for compatibility reasons. We want to change APIs that operate
on X11 objects to take the X11 objects as arguments. However, this would
break a lot of APIs and we'd like to avoid this, so we play this little
trick (we will use the same trick for the other X11 objects). Also,
gobject-introspection and other bindings can correctly attach the
functions to the correct types as it is the same scheme that GDK2 used
for pixmaps, windows and drawables.

For GTK 4, we will remove this trick, so apps should properly cast their
objects right now.
Unfortunately, I don't think there is a way to use
GDK_DISABLE_DEPRECATED or similar macros to check for proper type casts
while compiling ensure compatibility with future GDK versions. I'm free
to consider them though.

x11: Export GdkX11Display

x11: Rename GdkDisplayX11 to GdkX11Display

Also rename all the macros etc.

x11: Rename GdkDisplayX11 to GdkX11Display

API: gdk: GDK_DISPLAY_OBJECT() => GDK_DISPLAY()

GDK_DISPLAY_OBJECT is now deprecated. No need to keep failures from
gtk1 around.

x11: Move remaining APIs into gdkx11utils.h

Now gdkx.h is a clean header equivalent to gdk.h.

x11: Move atom API into gdkx11property.h

x11: Move selection-specific API into gdkx11selection.h

x11: Move display-specific APIs into gdkx11display.h

x11: Move screen-specific API into gdkx11screen.h

x11: Move visual-specific API into gdkx11visual.h

x11: Move cursor API into gdkx11cursor.h

x11: Split out public window API into gdkx11window.h

API: gdk: gdk_display_warp_device() => gdk_device_warp()

warping devices has nothing to do with displays, so putting it there
seems weird.

gdk: Move gdk_cursor_get_image() to the base class

.. and make it call a vfunc on the cursor

x11: Remove duplicated docs

They're in gdk/gdkdisplay.c now.

x11: Don't keep the display around anymore

Use gdk_cursor_get_display() instead.

gdk: Move gdk_cursor_get_display() out of the backends

Now that we store the display inside the cursor, that change is obvious.

gdk: Make display a property of GdkCursor

gdk: Make cursor-type a property of the cursor

API: gdk: Deprecate gdk_cursor_ref() and gdk_cursor_unref()

Now that GdkCursor is a GObject, it doesn't need custom refcount
handling anymore.

testgtk: Use g_object_unref instead of gdk_cursor_unref

gtk-demo: Use g_object_unref instead of gdk_cursor_unref

gtk: Use g_object_unref instead of gdk_cursor_unref

gdk: Use g_object_(un)ref instead of gdk_cursor_(un)ref

x11: Use g_object_(un)ref instead of gdk_cursor_(un)ref

gdk: Make GdkCursor a GObject

Also port the X11 implementation. Win32 and Quartz need to be ported
still.

gdk: Move GdkCursor definition into a private header

x11: Move GdkCursorPrivate into the C file

x11: Use public API to access cursor's xcursor

Downgrade some Since tags

Add win32 implementation for foreign window functions

Drop sm_client_id implementation for Quartz

Drop sm_client_id win32 implementation

Reinstate the correct field value

Deal with property encoding functions

Move everything dealing with compound text to be X11 specific
Only gdk_text_property_to_utf8_list and gdk_utf8_to_string_target
are kept across backends, so add vfuncs for these.

Also, remove the non-multihead-safe variants of all these.

Avoid unnecessary use of gdk conversion routines

We can use use gtk_selection_data_get_uris, instead of
manually doing the conversion ourselves.

Add a vfunc for gdk_selection_convert

Add a vfunc for  gdk_selection_property_get

Add a vfunc for gdk_selection_send_notify_for_display

Rename some private x11 backend functions to _gdk_x11

Add vfuncs for get/set_selection_owner

Add vfuncs for keyval and window property functions

The keyval functions should really be generic, and the window
property api should be completely revisited, but for now this
will allow us to proceed.

Drop g[dt]k_set_locale

These functions were essentially just calling setlocale anyway.
The X11 version was also setting a gdk_use_mb variable that
is not used anywhere.

Don't use gtk_set_locale

Add vfuncs for gdk_test apis

Add vfuncs for atoms

Add a vfunc for gdk_keymap_get_for_display

Rename private keymap symbols to _gdk_x11_keymap...

Rename the _gdk_xid_table functions

Remove gdk_net_wm_supports

This function is totally misnamed, only operates on the default
screen, and has a perfectly fine replacement in
gdk_x11_screen_supports_net_wm_hint.

Remove the --sync commandline option

Remove the --sync option and remove the possibility of backend-specific
commandline options altogether. --sync is being replaced by
a GDK_SYNCHRONIZE environment variable.

Remove unused _gdk_use_xshm global

Rename _gdk_window_move_resize_child

Rename _gdk_window_move_resize_child and _gdk_window_process_expose
to _gdk_x11.

Clean up gdkx.h a bit

Moving the direct-access redefinitions of various macros
to gdkprivate-x11.h and use that header throughout in x11/.

Also remove a workaround for a long-fixed X server bug.

drop dead function

Add a vfunc for _gdk_window_impl_new

Get rid of the _gdk_selection_property global

Rename _gdk_moveresize functions to _gdk_x11_moveresize

Drop gdkx_visual_get

The function is badly named, not multihead-safe, basically unused,
and has a better replacement with gdk_x11_screen_lookup_visual.

Rename _gdk_xgrab_ apis to _gdk_x11_window_

Rename _gdk_send_xevent to _gdk_x11_display_send_xevent

Rename _gdk_event_mask_table to _gdk_x11_event_mask_table

Multiple changes to reduce the amount of unprefixed symbols

The X11 backend exports a number of symbols which are _-prefixed
(so don't become part of the gdk api), but are not named in a
way to prevent accidental clashes between backends.

The one API change here is that the gdk_xid_table functions
have been removed - they did not server an purpose, since the
xid table only stores windows anyway, and we already have a
lookup-by-xid function for windows.

plug: Comment hack for xinput that used private x11 backend API

Move event source apis to gdk_x11

Reduces the changes of cross-backend collisions

Remove gdk_spawn functions

These functions were trivial g_spawn wrappers in all backends
except for X11, and they can be easily replaced by
g_app_info_create_for_commandline + GdkAppLaunchContext.

Don't use gdk_spawn

Replace the sole use of gdk_spawn in GTK+ by GAppInfo.

Work around issues with events without screens

Just use the default display for copy/free of event data.
Maybe the vfuncs should be moved to GdkDisplayManager.

Make GdkAppLaunchContext work again

We didn't set the display, ever. Add a construct-only property
for this purpose.

Consistently use per-display error traps in the X11 backend

Make gdk_window_{lookup,foreign_new}_for_display backend specific

At the same time, make GDK_IS_DISPLAY_X11 available in gdkx.h, and
add some exemplaric ifdefs to GTK+ code.